home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / demo / igps_102.zip / TALKSOCK.CPP < prev    next >
C/C++ Source or Header  |  1994-12-01  |  23KB  |  767 lines
  1. ///////////////////////////////////////////////////////////////////////////////////
  2. // Internet Global Phone Project
  3. // talksock.h : Implementation of the CTalkClient, CTalkListenServer, and CTalkServer
  4. //              classes
  5. //
  6. // The CTalk... classes implements protocol specific behaviours on top of the
  7. // CSocketOwner, CSockServer, CSockClient, and CSockListenServer base classes.
  8. // See the main text of article in Dr. Dobb's Journal for a discussion of the
  9. // class hierachy. A discussion of the protocol can also be found in the text.
  10. //
  11. ////////////////////////////////////////////////////////////////////////////////////
  12. // Copyright (c) 1993-1994    microWonders Inc.  All rights reserved.
  13. //                                                                         
  14. // AN OPEN INVITION TO BUILD UPON AND CONTRIBUTE TO THE PUBLIC TECHNOLOGY POOL:
  15. // You are encouraged to redistribute, and build upon the technologies presented 
  16. // in this source module and the accompanying article in Dr. Dobb's Journal provided 
  17. // all the conditions listed in the MUSTREAD.TXT file, included with this 
  18. // distribution, are met.
  19. ////////////////////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h" 
  21. #include "mmsystem.h"
  22. #include "mphone.h"
  23.  
  24. #include "phonedoc.h"  
  25. #include "wsmin.h"
  26. #include "socket.h"  
  27. #include "talksock.h"
  28. #include "phonevw.h"
  29.  
  30.  
  31. #ifdef _DEBUG
  32. #undef THIS_FILE
  33. static char BASED_CODE THIS_FILE[] = __FILE__;
  34. #endif   
  35.  
  36.  
  37.  
  38.  
  39. ////////////////////////////////////////////////////////////////////////////////
  40. // CTalkServer  Class
  41. //
  42. // Philosophy of Implementation:  CONSERVATIVE
  43. //
  44. //    terminate and destroy connection, socket, server, and memory on any error
  45. //
  46. //  -->ensure integrity and security
  47. //
  48. // June 5, 1994     Fix up occasional lockup after send on some WINSOCKs,  the first
  49. //                 Recv on some WINSOCKs gives garbage upon connect.
  50. //
  51. // December 1, 1994        Disabled stringent error checking that caused the
  52. //                        program to abort connection at the slightest excuse
  53. //                        (PA)
  54. //
  55. CTalkServer::CTalkServer()
  56. {
  57.  
  58. }
  59.  
  60. CTalkServer::~CTalkServer()
  61. { 
  62. // Let the Phoneview free memory, since play maynot complete immediately.
  63. // That is, the Server object may be destroyed before audio play completed.   
  64. }  
  65.                                                                            
  66.                                                                            
  67. BOOL CTalkServer::GetBuffer()                                              
  68. {
  69.     // This routine is called by the Listener when dynamically creating
  70.     // a Server object.  The buffer is created to hold the transmitted
  71.     // compressed audio stream.
  72.     //
  73.     m_hspeechBuffer = GlobalAlloc(GHND , (DWORD) COMPRESSED_BUFSIZE);
  74.     if (!m_hspeechBuffer)
  75.     {
  76.       AfxGetMainWnd()->MessageBox("cannot allocate compress buffer!");
  77.       return (FALSE);
  78.     }             
  79.     m_pBuffer = (HPSTR) GlobalLock(m_hspeechBuffer);
  80.     if (!m_pBuffer)
  81.     {
  82.       GlobalUnlock(m_hspeechBuffer);
  83.       GlobalFree(m_hspeechBuffer);
  84.       AfxGetMainWnd()->MessageBox("cannot lock compress buffer!");
  85.       return (FALSE);
  86.     }    
  87.     m_pCurBuf = m_pBuffer;  // set sliding ptr
  88.     return(TRUE);  
  89. }
  90.  
  91.  
  92. void CTalkServer::OnOtherMsgs(int iEvent, int iError)
  93. {     
  94.   // override the 'catch all' virtual function to trap our special
  95.   // WSTALKBEGIN message.  This message is sent as soon as the
  96.   // server thread comes alive.
  97.   //
  98.   // We start the first element of the protocol by sending an
  99.   // ACK.è  if (iEvent == WSTALKBEGIN)
  100.   {
  101.        BOOL bResult;  
  102.        UINT tmpLen;
  103.        
  104.        m_state = S_RESET;
  105.        
  106.        lstrcpy(m_szBuffer, "ACK\r\n");
  107.        TRACE("Server sending first ACK\n");
  108.        tmpLen = lstrlen( m_szBuffer) + 1;         // start with an ACK
  109.        bResult = Send((LPCSTR) m_szBuffer, tmpLen);
  110.        if (bResult != TRUE)
  111.        {
  112.             CallBack(WSCHILDCLOSED, MyLastError());
  113.             CancelIO();
  114.             DestroySocket();
  115.             delete this;
  116.        }
  117.        else
  118.         m_state = S_ACK1;                  
  119.                          
  120.    }
  121. }        
  122.  
  123.  
  124. void CTalkServer::OnReceiveCompleted(int iEvent, int iError)
  125. {     
  126.     // A Winsock receive operation has completed.
  127.     // Handle protocol states requirements here
  128.     //
  129.       if (iError == 0)
  130.       { 
  131.        switch(m_state)
  132.        {
  133.        case S_READSIZE:                          
  134.          // get the audio buffer size to receive
  135.           m_szBuffer[LastRecvLength()] = '\0';
  136.           TRACE("Server got ->%s<-\n", m_szBuffer);            
  137.           m_bufSize  = atol(&m_szBuffer[4]);
  138.           TRACE("Server expect size = ->%lu<-\n", m_bufSize);          
  139.           SendAck();
  140.           break; 
  141.        case S_READTYPE:                         
  142.           // get the audio data type to receive, we only accept 1 type
  143.           m_szBuffer[LastRecvLength()] = '\0';
  144.              m_compressionType = atoi(&m_szBuffer[4]); 
  145.           TRACE("Server got ->%s<-\n", m_szBuffer);             
  146.           SendAck();
  147.           break;
  148.        case S_READDATA:                                              
  149.          // keep reading in small chunks until all audio data are received
  150.           if (DataRead() == DONE)
  151.            {  
  152.             TRACE("Server has completed all data read, sending final ack!\n");           
  153.             SendAck();
  154.            } 
  155.           break;
  156.        }
  157.       }
  158.       else
  159.       {                                        
  160.         TRACE("Disconnect from error code %d\n", iError);      
  161.         CallBack(WSCHILDCLOSED, iError);
  162.         CancelIO();
  163.         DestroySocket();
  164.         delete this;
  165.       }
  166. }
  167.  
  168.  
  169. void CTalkServer::OnSendCompleted(int iEvent, int iError)
  170. {                                                                         
  171.   // Winsock Send operation completed.
  172.   // We handle protocol requirements and transition protocol states
  173.   // here.
  174.      if (iError == 0)
  175.       { 
  176.        BOOL bResult;
  177.        // got an ack sent
  178.        switch (m_state)
  179.        {
  180.         case S_ACK1:
  181.         case S_READTYPE:
  182.         case S_READSIZE:                                    
  183.           // simplified coding: DATACHUNKSIZE is actually too large for
  184.           // S_ACK1 and S_READTYPE states, but it works okay as maximum size
  185.           bResult = Recv((LPSTR) m_szBuffer, DATACHUNKSIZE);
  186.           if (bResult != TRUE)
  187.           {
  188.            CallBack(WSCHILDCLOSED, MyLastError());
  189.            CancelIO();
  190.            DestroySocket();
  191.            delete this;
  192.           }
  193.           else 
  194.            {
  195.              // advance to next state
  196.             m_state = ((m_state == S_ACK1) ? S_READTYPE : 
  197.             ((m_state == S_READTYPE) ? S_READSIZE : S_READDATA));
  198.             
  199.             }
  200.            break;        
  201.          case S_READDATA:
  202.            // final ack, can start processing the data
  203.            // if we want here; we'll just set a flag, and send voice
  204.            // when client disconnects 
  205. TRACE("Server complete sending final ack!\n");           
  206.              m_speechReady = TRUE;
  207.            break;
  208.         } // of switch
  209.            
  210.       } //of iError = 0   
  211.      else
  212.         {
  213.           CallBack(WSCHILDCLOSED, iError);
  214.           CancelIO();
  215.           DestroySocket();
  216.           delete this;
  217.          }
  218. }                
  219.  
  220. UINT CTalkServer::DataRead()
  221. {                
  222.         // got another buffer
  223.                          
  224.        BOOL bResult;
  225.        int RecvSize = LastRecvLength();
  226.                                                  
  227.        ASSERT(RecvSize > 0);                                        
  228.        
  229.         _fmemcpy( m_pCurBuf, m_szBuffer, RecvSize); 
  230.        
  231.         
  232.        m_pCurBuf += RecvSize;     
  233.        
  234.        if (((ULONG)(m_pCurBuf - m_pBuffer)) < m_bufSize)   // need more
  235.        {
  236.          bResult = Recv((LPSTR) m_szBuffer, DATACHUNKSIZE);
  237.          if (bResult != TRUE)
  238.          {
  239.            CallBack(WSCHILDCLOSED, MyLastError());
  240.            CancelIO();
  241.            DestroySocket();
  242.            delete this;
  243.           } 
  244.           
  245.          else 
  246.            return TRUE; 
  247.         }
  248.         else  // don't need any more
  249.         {  
  250.          return (DONE);
  251.         } 
  252.   return TRUE; // never reach here anyway; surpress compiler warning
  253. }
  254.        
  255. void CTalkServer::SendAck()
  256. {
  257.         BOOL bResult;
  258.         UINT tmpLen;
  259.  
  260.       // Routine to send an ACK
  261.       // 
  262.               
  263.         // start with an ACK 
  264.         lstrcpy(m_szBuffer, "ACK\r\n");
  265. TRACE("In Server sending ack = ->%s<-\n", m_szBuffer);
  266.         tmpLen = lstrlen( m_szBuffer) + 1;  // send only enough for compatibility w UNIX   
  267.       bResult = Send((LPCSTR) m_szBuffer, tmpLen);        
  268.        if (bResult != TRUE)
  269.        {
  270.             CallBack(WSCHILDCLOSED, MyLastError());
  271.             CancelIO();
  272.             DestroySocket();
  273.             delete this;
  274.        }
  275.                  
  276.  
  277. }
  278.  
  279. void CTalkServer::OnDisconnected(int iEvent, int iError)
  280. {                                
  281.     if (m_speechReady == TRUE)
  282.     {
  283.      // send voice to output
  284.      // PhoneView will free the buffer after playback
  285.      m_PhoneView->ExpandWaveOut( m_hspeechBuffer, m_pBuffer, m_bufSize);
  286.     
  287.     }
  288.      CallBack(WSCHILDCLOSED, iError);
  289.      Notify(m_socket, WSCHILDCLOSED, iError); 
  290.      CancelIO();
  291.      DestroySocket(); 
  292.      delete this;
  293. }
  294.  
  295. /////////////////////////////////////////////////////////////////////////////
  296. // CTalkServer diagnostics
  297.  
  298. #ifdef _DEBUG
  299. void CTalkServer::AssertValid() const
  300. {
  301.     CSocketOwner::AssertValid();
  302. }
  303.  
  304. void CTalkServer::Dump(CDumpContext& dc) const
  305. {
  306.     CSocketOwner::Dump(dc);
  307. }
  308.  
  309. #endif //_DEBUG
  310.  
  311.  
  312. ////////////////////////////////////////////////////////////////////////
  313. // CTalkClient
  314. //
  315. // Philosophy of Design: CONSERVATIVE
  316. //
  317. // terminate and destroy connection, socket, and client on any error
  318. //                        
  319. // Preferred Philosophy of Design: LIBERAL
  320. //   flow the protocol, let timer detect failure retry and disconnect; this
  321. //   is not implemented here
  322. //
  323. CTalkClient::CTalkClient()
  324. {
  325. }
  326.  
  327. CTalkClient::~CTalkClient()
  328. {
  329. }  
  330.  
  331.  
  332. WSSOCKET CTalkClient::Connect( 
  333.  UINT prot, WSADDRESS iaddress, WSPORTID iPort, UINT uInterval, 
  334.  HWND hCallBack, NOTIFYPROC fNotify, UINT uLimit, HPSTR talkBuffer, ULONG bufLen)
  335. {  
  336.   // make connection and start protocol, UDP is never used currently
  337.   int iProtocol = GetProtocolByName( (prot == TCPSOCK)? "tcp":"udp");
  338.  
  339.   if (iPort == 0)
  340.    iPort=GetServiceByName("intertalk", (prot == TCPSOCK)? "tcp":"udp");
  341.    
  342.   m_socket = CreateSocket(prot, iProtocol,0, sizeof(LPSTR), hCallBack,
  343.  UniversalCSockOwnerNotify);        
  344.  
  345.   if (m_socket != NOTASOCK)
  346.   {                                                      
  347.     // Store a pointer to myself (this object) with the socket
  348.     // associated memory; this allows all socket related messages
  349.     // to find their way back to us. 
  350.     CTalkClient * __far * pto = (CTalkClient * __far *) GetSockMemory();
  351.     *pto = this;
  352.     m_iType = WS_TALKCLIENT;
  353.     // for udp sockets, the address is required
  354. //    if (prot == UDPSOCK) 
  355. //      m_lAddress = GetHostByName(lpName);
  356. //    else
  357. //      m_lAddress = INADDR_NONE;
  358. //    m_uPort = iPort;
  359. //    m_lRecvAddress = INADDR_NONE;
  360. //    m_uSequence = 0;
  361. //    m_bInProgress = FALSE;
  362. //    m_uInterval= (uInterval < MIN_UINTERVAL) ? MIN_UINTERVAL: uInterval;
  363. //    m_uLimit = uLimit;
  364.     m_fNotifyProc = fNotify;
  365.     m_bConnected = (prot == TCPSOCK) ? TRUE: FALSE;
  366.     
  367.     m_talkBuffer = talkBuffer;   
  368.     m_pCurBuf = talkBuffer; 
  369.     
  370.     m_bufLen = bufLen;
  371.  
  372.     if (m_bConnected == TRUE)
  373.     {
  374.       if(ConnectTo(/* MyAddress() */ iaddress, iPort) != TRUE)
  375.       {  
  376.        Notify(m_socket, WSCONNECTED, 998);
  377.        DestroySocket();
  378.        m_socket =  NOTASOCK;    
  379.        }  // of if connect
  380.      }
  381.      else
  382.        Notify(m_socket, WSCONNECTED, 0);
  383.     }  // of if (m_socket != NOTASOCK)
  384.    return (m_socket);
  385. } // of ConnectByName   
  386.       
  387.  
  388.  
  389. void CTalkClient::OnConnected(int iEvent, int iError)
  390. { 
  391.   // Connect completed, we now have a TCP connection.  Start the
  392.   // protocol by waiting for the initial ACK on a Recv.
  393.   
  394.   if (1) //iError == 0)
  395.   { 
  396.       if (CreateTimer(m_uInterval) == TRUE)
  397.       {
  398.       BOOL bResult;
  399.       
  400.       if(m_bConnected == TRUE)
  401.        bResult = Recv((LPSTR) &m_szBuffer, DATACHUNKSIZE);
  402.       
  403.        if (bResult == FALSE)
  404.        { 
  405.          m_state = S_RESET;
  406.          m_bInProgress = FALSE;
  407.         }
  408.        else
  409.         {
  410.           m_state = S_ACK1;
  411.           m_bInProgress = TRUE;
  412.          } 
  413.  
  414.      } // of CreateTimer == TRUE
  415.      else
  416.      {   // unable to create Timer  
  417.        m_bInProgress = FALSE;
  418.        CallBack(WSTALKFAILED, 0);
  419.      } 
  420.  
  421.    } // on iError == 0 
  422.     else
  423.     // not connected         
  424.      { 
  425.       m_bInProgress = FALSE;
  426.       }
  427.  
  428.    CallBack(WSCONNECTED,  iError);       
  429. }  
  430.  
  431.  
  432.  
  433.  
  434. void CTalkClient::OnSendCompleted(int iEvent, int iError)
  435. {           
  436.     // A Winsok Send operation has completed, handle the
  437.     // protocol requirements.  Usually by waiting for an ACK.
  438.     // See Dr. Dobb's Journal text for description of protocol.
  439.     if (iError == 0)
  440.     {
  441.       UINT bStatus;
  442.       switch(m_state)
  443.       {
  444.        case    S_READTYPE:
  445.        case S_READSIZE:                     
  446.            TRACE("In SEND TYPE OR SEND SIZE\n");       
  447.            GetAck();
  448.            break;
  449.        case S_READDATA:              
  450.          TRACE("In SEND DATA PHASE\n");       
  451.          bStatus = SendData();
  452.          if (bStatus == FALSE) // something went wrong
  453.            {  
  454.             TRACE("Something Went wrong in Send Data phase.\n");           
  455.             m_bInProgress = FALSE;
  456.             m_state = S_RESET;
  457.            }
  458.          if (bStatus == DONE)
  459.          {
  460.             TRACE("Send Data Completed! Wait for ACK!\n");            
  461.             GetAck(); // get final ack
  462.           }  
  463.          break;
  464.       }
  465.     }
  466.      else
  467.       {
  468.         m_uErrorCount++;
  469.         m_bInProgress = FALSE;
  470.       }           
  471. }           
  472.  
  473.  
  474. void CTalkClient::OnReceiveCompleted(int iEvent, int iError)
  475. {   
  476.    BOOL bResult;
  477.  
  478.    // A Winsock Recv opertion has completed.  Handle the protocol
  479.    // requirement and mark the state transitions.
  480.    //
  481.    if (1)//(iError == 0)
  482.     { 
  483.      UINT tmpLen;   
  484.      switch(m_state)
  485.      {
  486.     case S_ACK1: // send the type 
  487.         m_szBuffer[LastRecvLength()]='\0';            
  488.         TRACE("Client got %s\n", m_szBuffer);     
  489.            lstrcpy(m_szBuffer, "002 1\r\n");
  490.            tmpLen = lstrlen( m_szBuffer) + 1;  // send only enough for compatibility w UNIX
  491.            bResult = Send((LPCSTR) m_szBuffer, tmpLen);
  492.            if (bResult != TRUE)
  493.            {
  494.             CallBack(WSTALKFAILED, 0);
  495.             m_bInProgress == FALSE;
  496.             m_state = S_RESET;
  497.             OnDisconnected(iEvent, iError);
  498.            }                       
  499.            else
  500.              m_state = S_READTYPE;
  501.          break;
  502.     case S_READTYPE:  // send the size 
  503.         m_szBuffer[LastRecvLength()]='\0';
  504.         TRACE("Client got %s\n", m_szBuffer);     
  505.  
  506.            sprintf( m_szBuffer,"003 %lu\r\n", m_bufLen);   
  507.            TRACE("total COMPRESSED SIZE is: %lu\n", m_bufLen);
  508.            tmpLen = lstrlen(m_szBuffer) + 1; // send just enough
  509.            bResult = Send((LPCSTR) m_szBuffer, tmpLen);
  510.            if (bResult != TRUE)
  511.            {
  512.             CallBack(WSTALKFAILED, 0);
  513.             m_bInProgress == FALSE;
  514.             m_state = S_RESET;     
  515.             OnDisconnected(iEvent, iError);
  516.            }                       
  517.            else
  518.              m_state = S_READSIZE;
  519.            break;
  520.     case S_READSIZE:  // send the data  
  521.     m_szBuffer[LastRecvLength()]='\0';
  522.     TRACE("Client got %s\n", m_szBuffer);     
  523.  
  524.          // in case there's less data to sent than 1 block
  525.          m_lastSentSize = (m_bufLen > (ULONG) DATACHUNKSIZE) ? DATACHUNKSIZE : (UINT) m_bufLen;    
  526.     TRACE("Sending %d bytes...\n", m_lastSentSize);      
  527.          if (m_bConnected == TRUE)
  528.            bResult = Send((LPCSTR) m_pCurBuf, m_lastSentSize);
  529.          else
  530.            bResult = SendTo((LPCSTR) m_pCurBuf, m_lastSentSize, m_lAddress, m_uPort);
  531.            
  532.         if (bResult == FALSE)
  533.          { 
  534.            CallBack(WSTALKFAILED, 0);
  535.            m_bInProgress = FALSE;
  536.            m_uErrorCount++;  
  537.            OnDisconnected(iEvent, iError);
  538.          }
  539.          else 
  540.            {
  541.            m_bInProgress = TRUE;
  542.            m_state = S_READDATA;     
  543.  
  544.            }
  545.          break;
  546.     case S_READDATA: // done, got final ack, wrap up
  547.         TRACE("it is FINAL, got last ack, We're wrapping up.\n");       
  548.           OnDisconnected(iEvent, iError);
  549.           break;
  550.     } // of case
  551.       
  552.     } // of iError==0
  553.     else
  554.     {      
  555.       CallBack(WSTALKFAILED, 0);
  556.       m_uErrorCount++;
  557.       m_bInProgress = FALSE;
  558.       OnDisconnected(iEvent, iError);
  559.     }    
  560. }           
  561.  
  562. UINT CTalkClient::SendData()
  563. {
  564.    // break up the large block of data into multiple small sends
  565.    // to fit through the max buffer size allowed by Winsock
  566.  
  567.       m_pCurBuf += m_lastSentSize;  // mark another chunk sent
  568.       if (m_pCurBuf  <  (m_talkBuffer  + m_bufLen)) // NOT everything sent
  569.       {
  570.          BOOL bResult;
  571.          m_uAttempts++;                                   
  572.          UINT tmpval = (UINT)((m_talkBuffer + m_bufLen) - m_pCurBuf);
  573.          // potentially send last remaining block
  574.          m_lastSentSize = (tmpval > DATACHUNKSIZE) ? DATACHUNKSIZE : tmpval;    
  575.        TRACE("ACTUALLY Sending %d values\n", m_lastSentSize);           
  576.          if (m_bConnected == TRUE)
  577.           bResult = Send((LPCSTR) m_pCurBuf, m_lastSentSize);
  578.  
  579.  
  580.          if (bResult == FALSE)
  581.          {
  582.            m_bInProgress = FALSE;
  583.            m_uErrorCount++;                      
  584.            return FALSE;
  585.          }
  586.          else
  587.           { 
  588.             m_bInProgress = TRUE;
  589.             return TRUE;
  590.           } 
  591.      } // not everything send
  592.      else
  593.        return (DONE);
  594.                 
  595. }      
  596.  
  597. void CTalkClient::GetAck()
  598. {
  599.   BOOL bResult;
  600.       m_lRecvAddress = INADDR_NONE;
  601.           
  602.       if(m_bConnected == TRUE)
  603.          bResult = Recv((LPSTR) &m_szBuffer, DATACHUNKSIZE);
  604.       else
  605.         bResult = RecvFrom((LPSTR) &m_szBuffer, WSTALKBUFFERSIZE, 
  606.         (LPWSADDRESS) &m_lRecvAddress, (LPWSPORTID) &m_uRecvPort);
  607.       
  608.        if (bResult == FALSE)
  609.        { 
  610.     TRACE("Inside Get Ack, something went wrong!\n");       
  611.          m_state = S_RESET;
  612.          m_bInProgress = FALSE;
  613.         }
  614.        else
  615.         {
  616.           m_bInProgress = TRUE;
  617.         } 
  618. } 
  619.    
  620.   
  621.  
  622. void CTalkClient::OnTimerExpired(int iEvent, int iError)
  623. {
  624.   // Timer is not used currently.  Definitely can be used to
  625.   // make the protocol more robust by re-trying and/or 
  626.   // aborting after time-out, etc.
  627.   
  628.   if (KillTimer() == TRUE)
  629.    {  // timed out
  630.    }
  631.    CallBack(WSTALKBACK, 0);
  632. }
  633.    
  634.  
  635. void CTalkClient::OnDisconnected(int iEvent, int iError)
  636. {
  637.    KillTimer();
  638.    m_bInProgress = FALSE;
  639.   TRACE("Inside OnDisconnected!\n");
  640.    CancelIO();
  641.    CallBack(WSDISCONNECTED, iError);  
  642.    DestroySocket();  // kill it off
  643. }   
  644.  
  645. BOOL CTalkClient::End()
  646. {
  647.  BOOL bResult;
  648.  if (m_iType == WS_TALKCLIENT)
  649.    bResult = DestroySocket();
  650.  else
  651.    bResult = FALSE;
  652.  return bResult;
  653. }
  654.  
  655. /////////////////////////////////////////////////////////////////////////////
  656. // CSocketClient diagnostics
  657.  
  658. #ifdef _DEBUG
  659. void CTalkClient::AssertValid() const
  660. {
  661.     CSocketOwner::AssertValid();
  662. }
  663.  
  664. void CTalkClient::Dump(CDumpContext& dc) const
  665. {
  666.     CSocketOwner::Dump(dc);
  667. }
  668.  
  669. #endif //_DEBUG
  670.  
  671. ////////////////////////////////////////////////////////////////////////
  672. // CTalkListenServer
  673. //
  674. // Listen at the well-known port.  Upon foregin connection, dynamically
  675. // create a Server object, allocate memory, and start the server thread's
  676. // protocol handler.
  677. //
  678. CTalkListenServer::CTalkListenServer()
  679. {
  680.     // TODO: add member initialization code here
  681. }
  682.  
  683. CTalkListenServer::~CTalkListenServer()
  684. {
  685. }  
  686.  
  687.  
  688. WSSOCKET CTalkListenServer::StartListener(LPCSTR lpName, 
  689.  WSPORTID Port, LPWSADDRESS ConnAddr, HWND hCallBack, NOTIFYPROC fCallBack,  CPhoneView * phView)
  690. {
  691.   m_PhoneView = phView;                                                   
  692.                                                      
  693.   return (CSockListenServer::StartListener(lpName, Port, ConnAddr, hCallBack, fCallBack));
  694. }
  695.  
  696. void CTalkListenServer::OnOtherMsgs(int iEvent, int iError)  
  697. {                   
  698.  // override the virtual 'catch-all' and intercepts the Accept() message
  699.  // to spin-off our Protocol specific Server process
  700.  //
  701.    if (iEvent == WSACCEPTCOMPLETE && (WSSOCKET)iError != NOTASOCK)
  702.    {
  703.      WSSOCKET iNewSocket = AttachSocket((HSOCK)iError, (int) sizeof(LPSTR),
  704.       MyCallBack(),
  705.      (NOTIFYPROC) UniversalCSockOwnerNotify);    
  706.  
  707.       
  708.       if (iNewSocket != NOTASOCK)  // attach sucessful
  709.       {                                                      
  710.       CTalkServer * nuServer = new(CTalkServer);   
  711.       if (nuServer != NULL)
  712.       {   
  713.        nuServer->SetSafeSocket(iNewSocket);
  714.        nuServer->m_PhoneView = m_PhoneView;
  715.  
  716.        if (nuServer->GetBuffer() == TRUE)  // try to allocate full speech Buffer 1st
  717.         { 
  718.          CTalkServer * __far * optr = (CTalkServer * __far *) nuServer->GetSockMemory();
  719.          if (optr != NULL)    
  720.          {                           
  721.           *optr = nuServer;
  722.           nuServer->m_fNotifyProc = m_fNotifyProc;
  723.           nuServer->m_iType = WSTALKCHILD;             
  724.           
  725.           nuServer->Notify(iNewSocket, WSTALKBEGIN, 0); 
  726.           CallBack( WSTALKNEWCHILD, (int) iNewSocket);       
  727.           }
  728.          else       
  729.           {
  730.           Notify(m_socket, WSTALKLISFAILED, IGP_NOMEM);
  731.           nuServer->DestroySocket(); 
  732.           delete nuServer;
  733.           } 
  734.         } // GetBuffer()
  735.        else
  736.           {  
  737.           Notify(m_socket, WSTALKLISFAILED, IGP_NOMEM);
  738.           nuServer->DestroySocket();
  739.           delete nuServer;
  740.           }
  741.       } // of nuServer != NULL        
  742.       else                                
  743.         {
  744.         Notify(m_socket, WSTALKLISFAILED, IGP_NOMEM);
  745.         WSDestroySocket(iNewSocket);    
  746.         }
  747.       }  // iNewSocket
  748.      }  // of iEvent   
  749. }
  750.  
  751. /////////////////////////////////////////////////////////////////////////////
  752. // CTalkListenServer diagnostics
  753.  
  754. #ifdef _DEBUG
  755. void CTalkListenServer::AssertValid() const
  756. {
  757.     CSocketOwner::AssertValid();
  758. }
  759.  
  760. void CTalkListenServer::Dump(CDumpContext& dc) const
  761. {
  762.     CSocketOwner::Dump(dc);
  763. }
  764.  
  765. #endif //_DEBUG
  766.  
  767.